YES 1.758 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/List.hs
H-Termination of the given Haskell-Program with start terms could successfully be proven:



HASKELL
  ↳ IFR

mainModule List
  ((union :: [Bool ->  [Bool ->  [Bool]) :: [Bool ->  [Bool ->  [Bool])

module List where
  import qualified Maybe
import qualified Prelude

  deleteBy :: (a  ->  a  ->  Bool ->  a  ->  [a ->  [a]
deleteBy _ _ [] []
deleteBy eq x (y : ys if x `eq` y then ys else y : deleteBy eq x ys

  elem_by :: (a  ->  a  ->  Bool ->  a  ->  [a ->  Bool
elem_by _ _ [] False
elem_by eq y (x : xsx `eq` y || elem_by eq y xs

  nubBy :: (a  ->  a  ->  Bool ->  [a ->  [a]
nubBy eq l 
nubBy' l [] where 
nubBy' [] _ []
nubBy' (y : ysxs 
 | elem_by eq y xs = 
nubBy' ys xs
 | otherwise = 
y : nubBy' ys (y : xs)

  union :: Eq a => [a ->  [a ->  [a]
union unionBy (==)

  unionBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]
unionBy eq xs ys xs ++ foldl (flip (deleteBy eq)) (nubBy eq ys) xs


module Maybe where
  import qualified List
import qualified Prelude



If Reductions:
The following If expression
if eq x y then ys else y : deleteBy eq x ys

is transformed to
deleteBy0 ys y eq x True = ys
deleteBy0 ys y eq x False = y : deleteBy eq x ys



↳ HASKELL
  ↳ IFR
HASKELL
      ↳ BR

mainModule List
  ((union :: [Bool ->  [Bool ->  [Bool]) :: [Bool ->  [Bool ->  [Bool])

module List where
  import qualified Maybe
import qualified Prelude

  deleteBy :: (a  ->  a  ->  Bool ->  a  ->  [a ->  [a]
deleteBy _ _ [] []
deleteBy eq x (y : ysdeleteBy0 ys y eq x (x `eq` y)

  
deleteBy0 ys y eq x True ys
deleteBy0 ys y eq x False y : deleteBy eq x ys

  elem_by :: (a  ->  a  ->  Bool ->  a  ->  [a ->  Bool
elem_by _ _ [] False
elem_by eq y (x : xsx `eq` y || elem_by eq y xs

  nubBy :: (a  ->  a  ->  Bool ->  [a ->  [a]
nubBy eq l 
nubBy' l [] where 
nubBy' [] _ []
nubBy' (y : ysxs 
 | elem_by eq y xs = 
nubBy' ys xs
 | otherwise = 
y : nubBy' ys (y : xs)

  union :: Eq a => [a ->  [a ->  [a]
union unionBy (==)

  unionBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]
unionBy eq xs ys xs ++ foldl (flip (deleteBy eq)) (nubBy eq ys) xs


module Maybe where
  import qualified List
import qualified Prelude



Replaced joker patterns by fresh variables and removed binding patterns.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
HASKELL
          ↳ COR

mainModule List
  ((union :: [Bool ->  [Bool ->  [Bool]) :: [Bool ->  [Bool ->  [Bool])

module List where
  import qualified Maybe
import qualified Prelude

  deleteBy :: (a  ->  a  ->  Bool ->  a  ->  [a ->  [a]
deleteBy vw vx [] []
deleteBy eq x (y : ysdeleteBy0 ys y eq x (x `eq` y)

  
deleteBy0 ys y eq x True ys
deleteBy0 ys y eq x False y : deleteBy eq x ys

  elem_by :: (a  ->  a  ->  Bool ->  a  ->  [a ->  Bool
elem_by vz wu [] False
elem_by eq y (x : xsx `eq` y || elem_by eq y xs

  nubBy :: (a  ->  a  ->  Bool ->  [a ->  [a]
nubBy eq l 
nubBy' l [] where 
nubBy' [] vy []
nubBy' (y : ysxs 
 | elem_by eq y xs = 
nubBy' ys xs
 | otherwise = 
y : nubBy' ys (y : xs)

  union :: Eq a => [a ->  [a ->  [a]
union unionBy (==)

  unionBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]
unionBy eq xs ys xs ++ foldl (flip (deleteBy eq)) (nubBy eq ys) xs


module Maybe where
  import qualified List
import qualified Prelude



Cond Reductions:
The following Function with conditions
nubBy' [] vy = []
nubBy' (y : ysxs
 | elem_by eq y xs
 = nubBy' ys xs
 | otherwise
 = y : nubBy' ys (y : xs)

is transformed to
nubBy' [] vy = nubBy'3 [] vy
nubBy' (y : ysxs = nubBy'2 (y : ysxs

nubBy'1 y ys xs True = nubBy' ys xs
nubBy'1 y ys xs False = nubBy'0 y ys xs otherwise

nubBy'0 y ys xs True = y : nubBy' ys (y : xs)

nubBy'2 (y : ysxs = nubBy'1 y ys xs (elem_by eq y xs)

nubBy'3 [] vy = []
nubBy'3 wz xu = nubBy'2 wz xu

The following Function with conditions
undefined 
 | False
 = undefined

is transformed to
undefined  = undefined1

undefined0 True = undefined

undefined1  = undefined0 False



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
HASKELL
              ↳ LetRed

mainModule List
  ((union :: [Bool ->  [Bool ->  [Bool]) :: [Bool ->  [Bool ->  [Bool])

module List where
  import qualified Maybe
import qualified Prelude

  deleteBy :: (a  ->  a  ->  Bool ->  a  ->  [a ->  [a]
deleteBy vw vx [] []
deleteBy eq x (y : ysdeleteBy0 ys y eq x (x `eq` y)

  
deleteBy0 ys y eq x True ys
deleteBy0 ys y eq x False y : deleteBy eq x ys

  elem_by :: (a  ->  a  ->  Bool ->  a  ->  [a ->  Bool
elem_by vz wu [] False
elem_by eq y (x : xsx `eq` y || elem_by eq y xs

  nubBy :: (a  ->  a  ->  Bool ->  [a ->  [a]
nubBy eq l 
nubBy' l [] where 
nubBy' [] vy nubBy'3 [] vy
nubBy' (y : ysxs nubBy'2 (y : ys) xs
nubBy'0 y ys xs True y : nubBy' ys (y : xs)
nubBy'1 y ys xs True nubBy' ys xs
nubBy'1 y ys xs False nubBy'0 y ys xs otherwise
nubBy'2 (y : ysxs nubBy'1 y ys xs (elem_by eq y xs)
nubBy'3 [] vy []
nubBy'3 wz xu nubBy'2 wz xu

  union :: Eq a => [a ->  [a ->  [a]
union unionBy (==)

  unionBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]
unionBy eq xs ys xs ++ foldl (flip (deleteBy eq)) (nubBy eq ys) xs


module Maybe where
  import qualified List
import qualified Prelude



Let/Where Reductions:
The bindings of the following Let/Where expression
nubBy' l []
where 
nubBy' [] vy = nubBy'3 [] vy
nubBy' (y : ysxs = nubBy'2 (y : ysxs
nubBy'0 y ys xs True = y : nubBy' ys (y : xs)
nubBy'1 y ys xs True = nubBy' ys xs
nubBy'1 y ys xs False = nubBy'0 y ys xs otherwise
nubBy'2 (y : ysxs = nubBy'1 y ys xs (elem_by eq y xs)
nubBy'3 [] vy = []
nubBy'3 wz xu = nubBy'2 wz xu

are unpacked to the following functions on top level
nubByNubBy'1 xv y ys xs True = nubByNubBy' xv ys xs
nubByNubBy'1 xv y ys xs False = nubByNubBy'0 xv y ys xs otherwise

nubByNubBy' xv [] vy = nubByNubBy'3 xv [] vy
nubByNubBy' xv (y : ysxs = nubByNubBy'2 xv (y : ysxs

nubByNubBy'2 xv (y : ysxs = nubByNubBy'1 xv y ys xs (elem_by xv y xs)

nubByNubBy'3 xv [] vy = []
nubByNubBy'3 xv wz xu = nubByNubBy'2 xv wz xu

nubByNubBy'0 xv y ys xs True = y : nubByNubBy' xv ys (y : xs)



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
HASKELL
                  ↳ Narrow

mainModule List
  (union :: [Bool ->  [Bool ->  [Bool])

module List where
  import qualified Maybe
import qualified Prelude

  deleteBy :: (a  ->  a  ->  Bool ->  a  ->  [a ->  [a]
deleteBy vw vx [] []
deleteBy eq x (y : ysdeleteBy0 ys y eq x (x `eq` y)

  
deleteBy0 ys y eq x True ys
deleteBy0 ys y eq x False y : deleteBy eq x ys

  elem_by :: (a  ->  a  ->  Bool ->  a  ->  [a ->  Bool
elem_by vz wu [] False
elem_by eq y (x : xsx `eq` y || elem_by eq y xs

  nubBy :: (a  ->  a  ->  Bool ->  [a ->  [a]
nubBy eq l nubByNubBy' eq l []

  
nubByNubBy' xv [] vy nubByNubBy'3 xv [] vy
nubByNubBy' xv (y : ysxs nubByNubBy'2 xv (y : ys) xs

  
nubByNubBy'0 xv y ys xs True y : nubByNubBy' xv ys (y : xs)

  
nubByNubBy'1 xv y ys xs True nubByNubBy' xv ys xs
nubByNubBy'1 xv y ys xs False nubByNubBy'0 xv y ys xs otherwise

  
nubByNubBy'2 xv (y : ysxs nubByNubBy'1 xv y ys xs (elem_by xv y xs)

  
nubByNubBy'3 xv [] vy []
nubByNubBy'3 xv wz xu nubByNubBy'2 xv wz xu

  union :: Eq a => [a ->  [a ->  [a]
union unionBy (==)

  unionBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]
unionBy eq xs ys xs ++ foldl (flip (deleteBy eq)) (nubBy eq ys) xs


module Maybe where
  import qualified List
import qualified Prelude



Haskell To QDPs


↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_nubByNubBy'1(xw142, xw143, xw144, xw145, False, [], ba) → new_nubByNubBy'(xw143, xw142, :(xw144, xw145), ba)
new_nubByNubBy'1(xw142, xw143, xw144, xw145, True, xw147, ba) → new_nubByNubBy'(xw143, xw144, xw145, ba)
new_nubByNubBy'1(xw142, xw143, xw144, xw145, False, :(xw1470, xw1471), ba) → new_nubByNubBy'1(xw142, xw143, xw144, xw145, new_esEs(xw1470, xw142, ba), xw1471, ba)
new_nubByNubBy'(:(xw500, xw501), xw51, xw52, bb) → new_nubByNubBy'1(xw500, xw501, xw51, xw52, new_esEs0(xw51, xw500, bb), xw52, bb)

The TRS R consists of the following rules:

new_esEs0(xw51, xw500, ty_Integer) → new_esEs4(xw51, xw500)
new_esEs11(xw10, xw90, dc, dd) → error([])
new_esEs14(True, False) → False
new_esEs14(False, True) → False
new_esEs0(xw51, xw500, app(ty_Ratio, bc)) → new_esEs3(xw51, xw500, bc)
new_esEs5(xw10, xw90) → error([])
new_esEs0(xw51, xw500, ty_Int) → new_esEs12(xw51, xw500)
new_esEs14(False, False) → True
new_esEs7(xw10, xw90) → error([])
new_esEs(xw1470, xw142, ty_Integer) → new_esEs4(xw1470, xw142)
new_esEs2(xw10, xw90) → error([])
new_esEs0(xw51, xw500, app(ty_[], bf)) → new_esEs8(xw51, xw500, bf)
new_esEs(xw1470, xw142, app(ty_Ratio, de)) → new_esEs3(xw1470, xw142, de)
new_esEs14(True, True) → True
new_esEs0(xw51, xw500, app(app(app(ty_@3, bh), ca), cb)) → new_esEs10(xw51, xw500, bh, ca, cb)
new_esEs0(xw51, xw500, app(app(ty_@2, cc), cd)) → new_esEs11(xw51, xw500, cc, cd)
new_esEs3(xw10, xw90, ce) → error([])
new_esEs8(xw10, xw90, cg) → error([])
new_esEs0(xw51, xw500, ty_Double) → new_esEs2(xw51, xw500)
new_esEs(xw1470, xw142, app(ty_Maybe, ea)) → new_esEs9(xw1470, xw142, ea)
new_esEs(xw1470, xw142, ty_Double) → new_esEs2(xw1470, xw142)
new_esEs4(xw10, xw90) → error([])
new_esEs13(xw10, xw90) → error([])
new_esEs0(xw51, xw500, app(app(ty_Either, bd), be)) → new_esEs6(xw51, xw500, bd, be)
new_esEs(xw1470, xw142, ty_Float) → new_esEs13(xw1470, xw142)
new_esEs0(xw51, xw500, ty_Char) → new_esEs1(xw51, xw500)
new_esEs(xw1470, xw142, app(ty_[], dh)) → new_esEs8(xw1470, xw142, dh)
new_esEs12(xw10, xw90) → error([])
new_esEs6(xw10, xw90, da, db) → error([])
new_esEs(xw1470, xw142, app(app(ty_Either, df), dg)) → new_esEs6(xw1470, xw142, df, dg)
new_esEs(xw1470, xw142, app(app(app(ty_@3, eb), ec), ed)) → new_esEs10(xw1470, xw142, eb, ec, ed)
new_esEs(xw1470, xw142, app(app(ty_@2, ee), ef)) → new_esEs11(xw1470, xw142, ee, ef)
new_esEs9(xw10, xw90, cf) → error([])
new_esEs1(xw10, xw90) → error([])
new_esEs(xw1470, xw142, ty_@0) → new_esEs5(xw1470, xw142)
new_esEs10(xw10, xw90, eg, eh, fa) → error([])
new_esEs(xw1470, xw142, ty_Char) → new_esEs1(xw1470, xw142)
new_esEs(xw1470, xw142, ty_Int) → new_esEs12(xw1470, xw142)
new_esEs0(xw51, xw500, ty_Bool) → new_esEs14(xw51, xw500)
new_esEs0(xw51, xw500, ty_Ordering) → new_esEs7(xw51, xw500)
new_esEs(xw1470, xw142, ty_Bool) → new_esEs14(xw1470, xw142)
new_esEs0(xw51, xw500, ty_@0) → new_esEs5(xw51, xw500)
new_esEs0(xw51, xw500, ty_Float) → new_esEs13(xw51, xw500)
new_esEs(xw1470, xw142, ty_Ordering) → new_esEs7(xw1470, xw142)
new_esEs0(xw51, xw500, app(ty_Maybe, bg)) → new_esEs9(xw51, xw500, bg)

The set Q consists of the following terms:

new_esEs0(x0, x1, ty_Char)
new_esEs10(x0, x1, x2, x3, x4)
new_esEs0(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs14(False, False)
new_esEs0(x0, x1, ty_Int)
new_esEs(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs(x0, x1, ty_Bool)
new_esEs(x0, x1, ty_@0)
new_esEs(x0, x1, app(ty_[], x2))
new_esEs7(x0, x1)
new_esEs(x0, x1, ty_Ordering)
new_esEs1(x0, x1)
new_esEs14(True, True)
new_esEs4(x0, x1)
new_esEs(x0, x1, ty_Float)
new_esEs2(x0, x1)
new_esEs(x0, x1, ty_Double)
new_esEs(x0, x1, ty_Integer)
new_esEs0(x0, x1, ty_Integer)
new_esEs0(x0, x1, app(app(ty_Either, x2), x3))
new_esEs3(x0, x1, x2)
new_esEs(x0, x1, app(app(ty_@2, x2), x3))
new_esEs0(x0, x1, ty_Double)
new_esEs0(x0, x1, app(ty_Ratio, x2))
new_esEs0(x0, x1, app(ty_Maybe, x2))
new_esEs5(x0, x1)
new_esEs14(True, False)
new_esEs14(False, True)
new_esEs0(x0, x1, ty_@0)
new_esEs13(x0, x1)
new_esEs11(x0, x1, x2, x3)
new_esEs(x0, x1, ty_Char)
new_esEs0(x0, x1, app(app(ty_@2, x2), x3))
new_esEs(x0, x1, app(app(ty_Either, x2), x3))
new_esEs9(x0, x1, x2)
new_esEs0(x0, x1, ty_Float)
new_esEs(x0, x1, app(ty_Ratio, x2))
new_esEs0(x0, x1, app(ty_[], x2))
new_esEs8(x0, x1, x2)
new_esEs(x0, x1, app(ty_Maybe, x2))
new_esEs0(x0, x1, ty_Ordering)
new_esEs12(x0, x1)
new_esEs6(x0, x1, x2, x3)
new_esEs0(x0, x1, ty_Bool)
new_esEs(x0, x1, ty_Int)

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_deleteBy0(xw17, xw18, xw19, False, ba) → new_deleteBy(xw19, xw17, ba)
new_deleteBy(xw10, :(xw90, xw91), bb) → new_deleteBy0(xw91, xw90, xw10, new_esEs15(xw10, xw90, bb), bb)

The TRS R consists of the following rules:

new_esEs15(xw10, xw90, ty_Integer) → new_esEs4(xw10, xw90)
new_esEs15(xw10, xw90, ty_Bool) → new_esEs14(xw10, xw90)
new_esEs11(xw10, xw90, cc, cd) → error([])
new_esEs14(True, False) → False
new_esEs14(False, True) → False
new_esEs5(xw10, xw90) → error([])
new_esEs15(xw10, xw90, app(app(ty_@2, cc), cd)) → new_esEs11(xw10, xw90, cc, cd)
new_esEs14(False, False) → True
new_esEs7(xw10, xw90) → error([])
new_esEs2(xw10, xw90) → error([])
new_esEs14(True, True) → True
new_esEs3(xw10, xw90, bc) → error([])
new_esEs8(xw10, xw90, bf) → error([])
new_esEs15(xw10, xw90, ty_Float) → new_esEs13(xw10, xw90)
new_esEs4(xw10, xw90) → error([])
new_esEs13(xw10, xw90) → error([])
new_esEs12(xw10, xw90) → error([])
new_esEs15(xw10, xw90, ty_Int) → new_esEs12(xw10, xw90)
new_esEs6(xw10, xw90, bd, be) → error([])
new_esEs15(xw10, xw90, ty_@0) → new_esEs5(xw10, xw90)
new_esEs15(xw10, xw90, app(app(app(ty_@3, bh), ca), cb)) → new_esEs10(xw10, xw90, bh, ca, cb)
new_esEs15(xw10, xw90, ty_Ordering) → new_esEs7(xw10, xw90)
new_esEs15(xw10, xw90, app(ty_Maybe, bg)) → new_esEs9(xw10, xw90, bg)
new_esEs15(xw10, xw90, ty_Double) → new_esEs2(xw10, xw90)
new_esEs9(xw10, xw90, bg) → error([])
new_esEs1(xw10, xw90) → error([])
new_esEs10(xw10, xw90, bh, ca, cb) → error([])
new_esEs15(xw10, xw90, ty_Char) → new_esEs1(xw10, xw90)
new_esEs15(xw10, xw90, app(ty_[], bf)) → new_esEs8(xw10, xw90, bf)
new_esEs15(xw10, xw90, app(ty_Ratio, bc)) → new_esEs3(xw10, xw90, bc)
new_esEs15(xw10, xw90, app(app(ty_Either, bd), be)) → new_esEs6(xw10, xw90, bd, be)

The set Q consists of the following terms:

new_esEs14(False, False)
new_esEs15(x0, x1, ty_Ordering)
new_esEs3(x0, x1, x2)
new_esEs8(x0, x1, x2)
new_esEs15(x0, x1, ty_Double)
new_esEs6(x0, x1, x2, x3)
new_esEs7(x0, x1)
new_esEs14(True, True)
new_esEs4(x0, x1)
new_esEs1(x0, x1)
new_esEs2(x0, x1)
new_esEs15(x0, x1, ty_@0)
new_esEs9(x0, x1, x2)
new_esEs15(x0, x1, app(ty_Ratio, x2))
new_esEs15(x0, x1, ty_Float)
new_esEs15(x0, x1, app(ty_Maybe, x2))
new_esEs15(x0, x1, ty_Char)
new_esEs15(x0, x1, ty_Int)
new_esEs5(x0, x1)
new_esEs14(True, False)
new_esEs14(False, True)
new_esEs15(x0, x1, app(app(ty_@2, x2), x3))
new_esEs15(x0, x1, app(app(ty_Either, x2), x3))
new_esEs13(x0, x1)
new_esEs10(x0, x1, x2, x3, x4)
new_esEs15(x0, x1, ty_Bool)
new_esEs12(x0, x1)
new_esEs11(x0, x1, x2, x3)
new_esEs15(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs15(x0, x1, app(ty_[], x2))
new_esEs15(x0, x1, ty_Integer)

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_foldl(xw9, xw10, :(xw110, xw111), ba) → new_foldl(new_flip(xw9, xw10, ba), xw110, xw111, ba)

The TRS R consists of the following rules:

new_esEs15(xw10, xw90, ty_Integer) → new_esEs4(xw10, xw90)
new_esEs15(xw10, xw90, ty_Bool) → new_esEs14(xw10, xw90)
new_esEs11(xw10, xw90, bg, bh) → error([])
new_esEs14(False, True) → False
new_esEs14(True, False) → False
new_esEs5(xw10, xw90) → error([])
new_esEs15(xw10, xw90, app(app(ty_@2, bg), bh)) → new_esEs11(xw10, xw90, bg, bh)
new_esEs14(False, False) → True
new_esEs7(xw10, xw90) → error([])
new_deleteBy00(xw17, xw18, xw19, True, ca) → xw17
new_esEs2(xw10, xw90) → error([])
new_esEs14(True, True) → True
new_esEs3(xw10, xw90, bb) → error([])
new_esEs8(xw10, xw90, bd) → error([])
new_esEs15(xw10, xw90, ty_Float) → new_esEs13(xw10, xw90)
new_esEs4(xw10, xw90) → error([])
new_esEs13(xw10, xw90) → error([])
new_deleteBy1(xw10, [], ba) → []
new_esEs12(xw10, xw90) → error([])
new_esEs15(xw10, xw90, ty_Int) → new_esEs12(xw10, xw90)
new_esEs15(xw10, xw90, app(app(app(ty_@3, cb), cc), cd)) → new_esEs10(xw10, xw90, cb, cc, cd)
new_esEs15(xw10, xw90, ty_@0) → new_esEs5(xw10, xw90)
new_esEs6(xw10, xw90, be, bf) → error([])
new_esEs15(xw10, xw90, app(ty_Maybe, bc)) → new_esEs9(xw10, xw90, bc)
new_esEs15(xw10, xw90, ty_Ordering) → new_esEs7(xw10, xw90)
new_deleteBy1(xw10, :(xw90, xw91), ba) → new_deleteBy00(xw91, xw90, xw10, new_esEs15(xw10, xw90, ba), ba)
new_deleteBy00(xw17, xw18, xw19, False, ca) → :(xw18, new_deleteBy1(xw19, xw17, ca))
new_esEs15(xw10, xw90, ty_Double) → new_esEs2(xw10, xw90)
new_esEs1(xw10, xw90) → error([])
new_esEs9(xw10, xw90, bc) → error([])
new_esEs10(xw10, xw90, cb, cc, cd) → error([])
new_flip(xw9, xw10, ba) → new_deleteBy1(xw10, xw9, ba)
new_esEs15(xw10, xw90, ty_Char) → new_esEs1(xw10, xw90)
new_esEs15(xw10, xw90, app(ty_[], bd)) → new_esEs8(xw10, xw90, bd)
new_esEs15(xw10, xw90, app(ty_Ratio, bb)) → new_esEs3(xw10, xw90, bb)
new_esEs15(xw10, xw90, app(app(ty_Either, be), bf)) → new_esEs6(xw10, xw90, be, bf)

The set Q consists of the following terms:

new_esEs14(False, False)
new_deleteBy1(x0, :(x1, x2), x3)
new_esEs15(x0, x1, ty_Ordering)
new_flip(x0, x1, x2)
new_esEs15(x0, x1, ty_Double)
new_esEs7(x0, x1)
new_esEs11(x0, x1, x2, x3)
new_esEs1(x0, x1)
new_esEs14(True, True)
new_esEs4(x0, x1)
new_esEs2(x0, x1)
new_esEs15(x0, x1, ty_@0)
new_deleteBy00(x0, x1, x2, False, x3)
new_esEs15(x0, x1, ty_Float)
new_esEs15(x0, x1, ty_Char)
new_deleteBy00(x0, x1, x2, True, x3)
new_esEs15(x0, x1, ty_Int)
new_deleteBy1(x0, [], x1)
new_esEs5(x0, x1)
new_esEs14(False, True)
new_esEs14(True, False)
new_esEs15(x0, x1, app(ty_Maybe, x2))
new_esEs10(x0, x1, x2, x3, x4)
new_esEs13(x0, x1)
new_esEs15(x0, x1, app(app(ty_Either, x2), x3))
new_esEs15(x0, x1, app(app(ty_@2, x2), x3))
new_esEs15(x0, x1, ty_Bool)
new_esEs15(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs15(x0, x1, app(ty_Ratio, x2))
new_esEs9(x0, x1, x2)
new_esEs15(x0, x1, app(ty_[], x2))
new_esEs3(x0, x1, x2)
new_esEs6(x0, x1, x2, x3)
new_esEs12(x0, x1)
new_esEs15(x0, x1, ty_Integer)
new_esEs8(x0, x1, x2)

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof

Q DP problem:
The TRS P consists of the following rules:

new_psPs(:(xw80, xw81), xw9, xw10, xw11, ba) → new_psPs(xw81, xw9, xw10, xw11, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: